home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / listings / v_02_07 / 2n07057a < prev    next >
Encoding:
Text File  |  1991-06-01  |  10.0 KB  |  394 lines
  1. #include <conio.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include "esp.h"
  5. #include "esp.fu"
  6.  
  7. #define OK     1
  8. #define FAIL   0
  9. #define bool   short
  10.  
  11. #define high(a) ((a) >> 8)
  12. #define low(a)  ((a) & 0xFF)
  13.  
  14. ESP_Reg esp_reg_info[] = {    /* Indexed by ESP_REG_... */
  15.    {ESP_REG_READY_OFFS,       0,                 },
  16.    {ESP_REG_SID_OFFS,         0,                 },
  17.    {ESP_REG_RX1_OFFS,         ESP_REG_RX1_RDY    },
  18.    {ESP_REG_TX1_OFFS,         ESP_REG_TX1_RDY    },
  19.    {ESP_REG_RX2_OFFS,         ESP_REG_RX2_RDY    },
  20.    {ESP_REG_TX2_OFFS,         ESP_REG_TX2_RDY    },
  21.    {ESP_REG_STATUS1_OFFS,     ESP_REG_STATUS1_RDY},
  22.    {ESP_REG_CMD1_OFFS,        ESP_REG_CMD1_RDY   },
  23.    {ESP_REG_STATUS2_OFFS,     ESP_REG_STATUS2_RDY},
  24.    {ESP_REG_CMD2_OFFS,        ESP_REG_CMD2_RDY   },
  25.    {ESP_DMA_RX_OFFS,          0,                 },
  26.    {ESP_DMA_TX_OFFS,          0,                 },
  27.    };
  28.  
  29. short esp_uart_addr[] =  /* bits 1-3 on DIP SW1 & SW2 */
  30.   {0x3F8, 0x2F8, 0x3E8, 0x2E8, 0x1E0, 0x1E8, 0x280, 0x288};
  31. short esp_irq[] =      /* bits 1-3 on DIP SW1 & SW2 */
  32.   {    4,     3,     4,     3,     9,     5,     9,     5};
  33.  
  34.  
  35. short ESP_InitHandle(esp_h,esp_no,port)
  36. ESP_Handle *esp_h;
  37. short esp_no;
  38. short port;
  39. {
  40.    char *esp_env;
  41.    short dips;
  42.  
  43.    if ((esp_env=getenv("HAYESESP")) == NULL) {
  44.       printf("Error:  please set HAYESESP = addr,dma,irq\n");
  45.       return FAIL;
  46.       }
  47.  
  48.    if (sscanf(esp_env,"%x,%d,%d", &esp_h->base_addr,
  49.       &esp_h->dma, &esp_h->irq) != 3) {
  50.       printf("Error:  please set HAYESESP = addr,dma,irq\n");
  51.       return FAIL;
  52.       }
  53.  
  54.    esp_h->esp_no = esp_no; /* always 1 or 2 */
  55.    esp_h->port = port;   /* always 1 or 2 (not COMx value!) */
  56.  
  57.    if (!(dips=ESP_GetNormalModeAddrSwitch(esp_h))) {
  58.       printf("Error:  MCA-bus version of ESP not yet supported!\n");
  59.       return FAIL;
  60.       }
  61.  
  62.    if (port==2)
  63.       dips >>= 4;
  64.    esp_h->uart_addr = esp_uart_addr[dips & 0x07];
  65.    return OK;
  66. }
  67.  
  68.  
  69. /****** SETUP COMMANDS ******/
  70.  
  71. short ESP_Reset(esp_h)   /* Reset an ESP (both ports) */
  72. ESP_Handle *esp_h;
  73. {
  74.    /* Flush out Status 1, if any data is left over */
  75.    if (inp(esp_h->base_addr + ESP_REG_READY_OFFS)
  76.           & ESP_REG_STATUS1_RDY)
  77.        ESP_WaitRead(esp_h, ESP_REG_STATUS1);
  78.  
  79.    ESP_WriteCmd1(esp_h, ESP_CMD_RESET);
  80.    return ESP_WaitRead(esp_h, ESP_REG_STATUS1);
  81. }
  82.  
  83. void ESP_GetSelfTestResults(esp_h, firmware_rev, test_results)
  84. ESP_Handle *esp_h;
  85. short *firmware_rev;
  86. short *test_results;
  87. {
  88.    ESP_WriteCmd1(esp_h, ESP_CMD_GET_SELF_TEST_RES);
  89.    *firmware_rev = ESP_WaitRead(esp_h, ESP_REG_STATUS1);
  90.    *test_results = ESP_WaitRead(esp_h, ESP_REG_STATUS2);
  91. }
  92.  
  93.  
  94. short ESP_GetNormalModeAddrSwitch(esp_h)
  95. ESP_Handle *esp_h;
  96. {
  97.    ESP_WriteCmd1(esp_h, ESP_CMD_GET_COMPAT_DIPS);
  98.    return ESP_WaitRead(esp_h, ESP_REG_STATUS1);
  99. }
  100.  
  101. void ESP_DownloadESPCode(esp_h, buffer, address, num_bytes)
  102. ESP_Handle *esp_h;
  103. char *buffer;
  104. short address;
  105. short num_bytes;
  106. {
  107.    short byte_no;
  108.  
  109.    ESP_WriteCmd1(esp_h, ESP_CMD_DOWNLOAD_CODE);
  110.    ESP_WriteCmd2WaitWord(esp_h, high(address), low(address));
  111.    ESP_WriteCmd2Wait(esp_h, num_bytes - 1);
  112.    for (byte_no=0; byte_no < num_bytes; byte_no++)
  113.       ESP_WriteCmd2Wait(esp_h, buffer[byte_no]);
  114. }
  115.  
  116. void ESP_SetEnhancedIntAndDMA(esp_h, int_dma_data)
  117. ESP_Handle *esp_h;
  118. short int_dma_data;
  119. {
  120.    ESP_WriteCmd1(esp_h, ESP_CMD_SET_INTR_AND_DMA);
  121.    ESP_WriteReg(esp_h, ESP_REG_CMD2, int_dma_data);
  122. }
  123.  
  124. void ESP_SetDMAtimeout(esp_h, timeout_ms)
  125. ESP_Handle *esp_h;
  126. short timeout_ms;
  127. {
  128.    ESP_WriteCmd1(esp_h, ESP_CMD_SET_DMA_TIMEOUT);
  129.    ESP_WriteReg(esp_h, ESP_REG_CMD2, timeout_ms / 10);
  130. }
  131.  
  132. void ESP_SetServiceRequestMask(esp_h, serv_rq_mask)
  133. ESP_Handle *esp_h;
  134. short serv_rq_mask;
  135. {
  136.    ESP_WriteReg(esp_h, ESP_REG_CMD1, ESP_CMD_SET_SERVICE_MASK);
  137.    ESP_WriteReg(esp_h, ESP_REG_CMD2, serv_rq_mask);
  138. }
  139.  
  140. void ESP_SetErrorStatusMask(esp_h, status_mask1, status_mask2)
  141. ESP_Handle *esp_h;
  142. short status_mask1;
  143. short status_mask2;
  144. {
  145.    ESP_WriteCmd1(esp_h, ESP_CMD_SET_ERROR_MASK);
  146.    ESP_WriteCmd2WaitWord(esp_h, status_mask1, status_mask2);
  147. }
  148.  
  149. void ESP_SetFlowControlType(esp_h, flow_type1, flow_type2)
  150. ESP_Handle *esp_h;
  151. short flow_type1;
  152. short flow_type2;
  153. {
  154.    ESP_WriteCmd1(esp_h, ESP_CMD_SET_FLOW_CTRL_TYPE);
  155.    ESP_WriteCmd2WaitWord(esp_h, flow_type1, flow_type2);
  156. }
  157.  
  158. void ESP_SetFlowControlChars(esp_h, control_chars)
  159. ESP_Handle *esp_h;
  160. char *control_chars;
  161. {
  162.    int i;
  163.  
  164.    ESP_WriteCmd1(esp_h, ESP_CMD_SET_FLOW_CTRL_CHAR);
  165.    for (i=0; i<5; i++)
  166.       ESP_WriteCmd2Wait(esp_h, control_chars[i]);
  167. }
  168.  
  169. void ESP_SetRXFlowControlLevels(esp_h, recv_off, recv_on)
  170. ESP_Handle *esp_h;
  171. short recv_off;
  172. short recv_on;
  173. {
  174.    ESP_WriteCmd1(esp_h, ESP_CMD_SET_RX_FIFO_LEVEL);
  175.    ESP_WriteCmd2WaitWord(esp_h, high(recv_off), low(recv_off));
  176.    ESP_WriteCmd2WaitWord(esp_h, high(recv_on), low(recv_on));
  177. }
  178.  
  179. void ESP_SetFIFOTriggerLevels(esp_h, rx_level, tx_level)
  180. ESP_Handle *esp_h;
  181. short rx_level;
  182. short tx_level;
  183. {
  184.    ESP_WriteCmd1(esp_h, ESP_CMD_SET_FIFO_TRIGGER);
  185.    ESP_WriteCmd2WaitWord(esp_h, high(rx_level), low(rx_level));
  186.    ESP_WriteCmd2WaitWord(esp_h, high(tx_level), low(tx_level));
  187. }
  188.  
  189. void ESP_SetReceiveCharTimeout(esp_h, timeout_ms)
  190. ESP_Handle *esp_h;
  191. short timeout_ms;
  192. {
  193.    ESP_WriteCmd1(esp_h, ESP_CMD_SET_RCV_CHAR_TMO);
  194.    ESP_WriteReg(esp_h, ESP_REG_CMD2, timeout_ms);
  195. }
  196.  
  197. void ESP_SetFlowedOffTimeout(esp_h, timeout_sec)
  198. ESP_Handle *esp_h;
  199. short timeout_sec;
  200. {
  201.    ESP_WriteCmd1(esp_h, ESP_CMD_SET_RCV_CHAR_TMO);
  202.    ESP_WriteReg(esp_h, ESP_REG_CMD2, timeout_sec);
  203. }
  204.  
  205. void ESP_WriteToUART(esp_h, uart_reg, uart_data)
  206. ESP_Handle *esp_h;
  207. short uart_reg;
  208. short uart_data;
  209. {
  210.    ESP_WriteCmd1(esp_h, ESP_CMD_WRITE_TO_UART);
  211.    ESP_WriteCmd2WaitWord(esp_h, uart_reg, uart_data);
  212. }
  213.  
  214. short ESP_ReadFromUART(esp_h, uart_reg)
  215. ESP_Handle *esp_h;
  216. short uart_reg;
  217. {
  218.    ESP_WriteCmd1(esp_h, ESP_CMD_READ_FROM_UART);
  219.    ESP_WriteReg(esp_h, ESP_REG_CMD2, uart_reg);
  220.    return ESP_WaitRead(esp_h, ESP_REG_STATUS1);
  221. }
  222.  
  223. void ESP_SetBaudRate(esp_h, baud_rate)
  224. ESP_Handle *esp_h;
  225. long baud_rate;
  226. {
  227.    short divisor;
  228.  
  229.    divisor = (short) (ESP_MAX_COMP_BAUD / baud_rate);
  230.    ESP_WriteCmd1(esp_h, ESP_CMD_SET_BAUD_RATE);
  231.    ESP_WriteCmd2WaitWord(esp_h, high(divisor), low(divisor));
  232. }
  233.  
  234. void ESP_GetMode(esp_h, def_mode, cur_mode)
  235. ESP_Handle *esp_h;
  236. short *def_mode;
  237. short *cur_mode;
  238. {
  239.    ESP_WriteCmd1(esp_h, ESP_CMD_GET_MODE);
  240.    *def_mode = ESP_WaitRead(esp_h, ESP_REG_STATUS1);
  241.    *cur_mode = ESP_WaitRead(esp_h, ESP_REG_STATUS2);
  242. }
  243.  
  244. void ESP_SetMode(esp_h, new_mode)
  245. ESP_Handle *esp_h;
  246. short new_mode;
  247. {
  248.    ESP_WriteCmd1(esp_h, ESP_CMD_SET_MODE);
  249.    ESP_WriteReg(esp_h, ESP_REG_CMD2, new_mode);
  250. }
  251.  
  252. /****** OPERATING COMMANDS ******/
  253.  
  254. void ESP_GetErrorStatus(esp_h, error1, error2)
  255. ESP_Handle *esp_h;
  256. short *error1;
  257. short *error2;
  258. {
  259.    ESP_WriteCmd1(esp_h, ESP_CMD_GET_MODE);
  260.    *error1 = ESP_WaitRead(esp_h, ESP_REG_STATUS1);
  261.    *error2 = ESP_WaitRead(esp_h, ESP_REG_STATUS2);
  262. }
  263.  
  264. void ESP_GetUARTStatus(esp_h, line_status, modem_status)
  265. ESP_Handle *esp_h;
  266. short *line_status;
  267. short *modem_status;
  268. {
  269.    ESP_WriteCmd1(esp_h, ESP_CMD_GET_UART_STATUS);
  270.    *line_status = ESP_WaitRead(esp_h, ESP_REG_STATUS1);
  271.    *modem_status = ESP_WaitRead(esp_h, ESP_REG_STATUS2);
  272. }
  273.  
  274. short ESP_GetRXBytesAvail(esp_h)
  275. ESP_Handle *esp_h;
  276. {
  277.    ESP_WriteCmd1(esp_h, ESP_CMD_GET_RX_BYTES_AVAIL);
  278.    return (ESP_WaitRead(esp_h, ESP_REG_STATUS1) << 8) +
  279.           (ESP_WaitRead(esp_h, ESP_REG_STATUS2));
  280. }
  281.  
  282. short ESP_GetTXSpaceAvail(esp_h)
  283. ESP_Handle *esp_h;
  284. {
  285.    ESP_WriteCmd1(esp_h, ESP_CMD_GET_TX_BYTES_AVAIL);
  286.    return (ESP_WaitRead(esp_h, ESP_REG_STATUS1) << 8) +
  287.           (ESP_WaitRead(esp_h, ESP_REG_STATUS2));
  288. }
  289.  
  290. void ESP_InitiateDMAReceive(esp_h)
  291. ESP_Handle *esp_h;
  292. {
  293.    ESP_WriteCmd1(esp_h, ESP_CMD_INIT_DMA_RECEIVE);
  294. }
  295.  
  296. void ESP_InitiateDMATransmit(esp_h)
  297. ESP_Handle *esp_h;
  298. {
  299.    ESP_WriteCmd1(esp_h, ESP_CMD_INIT_DMA_TRANSMIT);
  300. }
  301.  
  302. void ESP_FlowOffLocalTransmitter(esp_h)
  303. ESP_Handle *esp_h;
  304. {
  305.    ESP_WriteCmd1(esp_h,ESP_CMD_FLOW_OFF_LOC_XMIT);
  306. }
  307.  
  308. void ESP_FlowOnLocalTransmitter(esp_h)
  309. ESP_Handle *esp_h;
  310. {
  311.    ESP_WriteCmd1(esp_h,ESP_CMD_FLOW_ON_LOC_XMIT);
  312. }
  313.  
  314. void ESP_IssueLineBreak(esp_h, break_ms)
  315. ESP_Handle *esp_h;
  316. short break_ms;
  317. {
  318.    ESP_WriteCmd1(esp_h, ESP_CMD_ISSUE_LINE_BREAK);
  319.    ESP_WriteReg(esp_h, ESP_REG_CMD2, break_ms / 10);
  320. }
  321.  
  322. void ESP_FlushRxFIFO(esp_h)
  323. ESP_Handle *esp_h;
  324. {
  325.    ESP_WriteCmd1(esp_h, esp_h->port + ESP_CMD_FLUSH_RX_FIFO);
  326. }
  327.  
  328.  
  329. void ESP_FlushTxFIFO(esp_h)
  330. ESP_Handle *esp_h;
  331. {
  332.    ESP_WriteCmd1(esp_h, esp_h->port + ESP_CMD_FLUSH_TX_FIFO);
  333. }
  334.  
  335. /****** LOW-LEVEL ESP ACCESS ROUTINES ******/
  336.  
  337. short ESP_WaitRead(esp_h, esp_reg)
  338. ESP_Handle *esp_h;
  339. short esp_reg;
  340. {
  341.    short esp_reg_mask;
  342.  
  343.    esp_reg_mask = esp_reg_info[esp_reg].ready_flag;
  344.  
  345.    /* loop until register ready bit is true */
  346.    while (!(inp(esp_h->base_addr + ESP_REG_READY_OFFS)
  347.               & esp_reg_mask));
  348.    return inp(esp_h->base_addr + esp_reg_info[esp_reg].reg_offset);
  349. }
  350.  
  351.  
  352. void ESP_WriteReg(esp_h, esp_reg, cmd_data)
  353. ESP_Handle *esp_h;
  354. short esp_reg;
  355. short cmd_data;
  356. {
  357.    outp(esp_h->base_addr + esp_reg_info[esp_reg].reg_offset,
  358.         cmd_data);
  359. }
  360.  
  361. void ESP_WriteCmd1(esp_h, cmd1_data)
  362. ESP_Handle *esp_h;
  363. short cmd1_data;
  364. {
  365.    /* Op-code is modified by port number in some caes... */
  366.    if ((cmd1_data >= ESP_CMD_SET_ERROR_MASK) &&
  367.        (cmd1_data != ESP_CMD_CLEAR_DMA_SERV_RQ))
  368.       cmd1_data |= ESP_PORT2 * (esp_h->port == 2);
  369.  
  370.    outp(esp_h->base_addr + ESP_REG_CMD1_OFFS, cmd1_data);
  371. }
  372.  
  373. short ESP_WriteCmd2Wait(esp_h, cmd2_data)
  374. ESP_Handle *esp_h;
  375. short cmd2_data;
  376. {
  377.    outp(esp_h->base_addr + ESP_REG_CMD2_OFFS, cmd2_data);
  378.  
  379.    /* loop until register ready bit is true */
  380.    while (!(inp(esp_h->base_addr + ESP_REG_READY_OFFS)
  381.           & ESP_REG_CMD2_RDY));
  382.    return inp(esp_h->base_addr + ESP_REG_CMD2_OFFS);
  383. }
  384.  
  385.  
  386. void ESP_WriteCmd2WaitWord(esp_h, data1, data2)
  387. ESP_Handle *esp_h;
  388. short data1;
  389. short data2;
  390. {
  391.    ESP_WriteCmd2Wait(esp_h, data1);
  392.    ESP_WriteCmd2Wait(esp_h, data2);
  393. }
  394.